﻿#define _CRT_SECURE_NO_WARNINGS


//142. 环形链表 II
//给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
//如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，
//评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置
//（索引从 0 开始）。如果 pos 是 - 1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
//不允许修改 链表。
//示例 1：
//输入：head = [3, 2, 0, -4], pos = 1
//输出：返回索引为 1 的链表节点
//解释：链表中有一个环，其尾部连接到第二个节点。
//示例 2：
//输入：head = [1, 2], pos = 0
//输出：返回索引为 0 的链表节点
//解释：链表中有一个环，其尾部连接到第一个节点。
//示例 3：
//输入：head = [1], pos = -1
//输出：返回 null
//解释：链表中没有环。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
//struct ListNode* detectCycle(struct ListNode* head) {
//    struct ListNode* fast = head;
//    struct ListNode* slow = head;
//    while (fast && fast->next)
//    {
//        fast = fast->next->next;
//        slow = slow->next;
//        if (slow == fast)
//        {
//            struct ListNode* meet = slow;
//            struct ListNode* start = head;
//            while (meet != start)
//            {
//                start = start->next;
//                meet = meet->next;
//            }
//            return meet;
//        }
//    }
//    return NULL;
//}




#include <stdio.h>
#include <string.h>
//int main()
//{
//    int arr[128] = { 0 };
//    char str[501] = { 0 };
//    while (scanf("%s", str) != EOF)
//    {
//        int len = strlen(str);
//        int i = 0;
//        for (i = 0; i < len; i++)
//        {
//            if (str[i] >= 0 && str[i] <= 127)
//            {
//                arr[str[i]]++;
//            }
//        }
//        int count = 0;
//        for (i = 0; i < 128; i++)
//        {
//            if (arr[i] != 0)
//            {
//                count++;
//            }
//        }
//        printf("%d", count);
//    }
//    return 0;
//}

//
//int main()
//{
//	int x;
//	int y = 0;
//	y = ((x = 4 * 5, x * 5), x + 5);
//	printf("%d\n", y);
//	return 0;
//}

//自除数 是指可以被它包含的每一位数整除的数。
//例如，128 是一个 自除数 ，因为 128 % 1 == 0，128 % 2 == 0，128 % 8 == 0。
//自除数 不允许包含 0 。
//给定两个整数 left 和 right ，返回一个列表，列表的元素是范围 [left, right] 内所有的 自除数 。
//示例 1：
//输入：left = 1, right = 22
//输出：[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22]
//示例 2:
//输入：left = 47, right = 85
//输出：[48, 55, 66, 77]

//int* selfDividingNumbers(int left, int right, int* returnSize) {
//    int i = 0;
//    int* arr = (int*)calloc(1000, sizeof(int));
//    *returnSize = 0;
//    for (i = left; i <= right; i++)
//    {
//        int tmp = i;
//        while (tmp && tmp % 10)
//        {
//            if (i % (tmp % 10) == 0)
//            {
//                tmp /= 10;
//            }
//            else
//            {
//                break;
//            }
//        }
//        if (tmp == 0)
//        {
//            arr[*returnSize] = i;
//            *returnSize += 1;
//        }
//    }
//    return arr;
//}


//238. 除自身以外数组的乘积
//给你一个整数数组 nums，返回 数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积 。
//题目数据 保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在  32 位 整数范围内。
//请不要使用除法，且在 O(n) 时间复杂度内完成此题。
//示例 1:
//
//输入: nums = [1, 2, 3, 4]
//输出 : [24, 12, 8, 6]
//示例 2 :
//
//    输入 : nums = [-1, 1, 0, -3, 3]
//    输出 : [0, 0, 9, 0, 0]


int* productExceptSelf(int* nums, int numsSize, int* returnSize) {
    int* ret = (int*)calloc(numsSize, sizeof(int));
    int left = 1;
    int right = 1;
    *returnSize = numsSize;
    int i = 0;
    for (i = 0; i < numsSize; i++)
    {
        ret[i] = left;
        left *= nums[i];
    }
    for (i = numsSize - 1; i >= 0; i--)
    {
        ret[i] *= right;
        right *= nums[i];
    }

    return ret;

}